//
// Created by wangyz38535 on 2024/8/15.
//


#include <iostream>
#include <string>
#include <gtest/gtest.h>
#include <iostream>
#include <vector>

using namespace std;

/*
1. 修饰变量，说明该变量不可以被改变；
2. 修饰指针，分为指向常量的指针（pointer to const）和自身是常量的指针（常量指针，const pointer）；
3. 修饰引用，指向常量的引用（reference to const），用于形参类型，即避免了拷贝，又避免了函数对值的修改；
4. 修饰成员函数，说明该成员函数内不能修改成员变量。
  */

class A {
private:
    const int a;                    // 常量对象成员，可以使用初始化列表和类内初始化

public:
    // 构造函数
    A() : a(0) {}
    explicit A(int x) : a(x) {}  // 初始化列表进行初始化

//     const 也可用于对重载函数的区分，以下是两个函数
    int GetValue() const { return a + 1;}  // 常量成员函数，不能对任何数据成员进行修改
    int GetValue() {return a;}   // 普通成员函数
};

void function()
{
    // 对象
    A b;                        // 普通对象，可以调用全部成员函数
    const A a;                  // 常对象，只能调用常成员函数
    const A *p = &a;            // 指针变量，指向常对象
    const A &q = a;             // 指向常对象的引用

    // 指针
    char greeting[] = "Hello";
    char* p1 = greeting;                // 指针变量，指向字符数组变量
    const char* p2 = greeting;          // 指针变量，指向字符数组常量（const 后面是 char，说明指向的字符（char）不可改变）
    char const * p5 = greeting;         // 是指向常量的指针，还是常量指针，就开const是在*的前面还是在*的后面，在*的前面就是指向常量的指针
    // 但是指针本身不是常量，还可以指向其他的常量
    //p5 = ""; // Ok 指向常量的指针可以修改指向的内容，。只是指向的内容不能再改变
    char* const p3 = greeting;          // 自身是常量的指针，指向字符数组变量（const 后面是 p3，说明 p3 指针自身不可改变）
    //p3 = "";   // err : 常量指针不能修改指向
    const char* const p4 = greeting;    // 自身是常量的指针，指向字符数组常量
}

// 函数
void function1(const int Var);           // 传递过来的参数在函数内不可变
void function2(const char* Var);         // 参数指针所指内容为常量
void function3(char* const Var);         // 参数指针为常量
void function4(const int& Var);          // 引用参数在函数内为常量

// 函数返回值
const int function5();      // 返回一个常数
const int* function6();     // 返回一个指向常量的指针变量，使用：const int *p = function6();
int* const function7();     // 返回一个指向变量的常指针，使用：int* const p = function7();




TEST(DemoConstTest, demo) {
    const A a(12);
    EXPECT_EQ(13, a.GetValue());
    A a1(12);
    EXPECT_EQ(12, a1.GetValue());

}